home *** CD-ROM | disk | FTP | other *** search
/ Cracking 1 / Cracking I..iso / Tools / Debuggery / TRW2000 / PLUGSDK / INCLUDE / PLUGAPI.H < prev    next >
Encoding:
Text File  |  2000-04-26  |  19.0 KB  |  519 lines
  1.  
  2. typedef struct {
  3.     DWORD    PlugVersion;
  4.  
  5.     // Function Export!
  6.  
  7. //---------------------------------------------
  8.     // Hook 
  9.     VOID    (__stdcall*hook)( PPHOOKER hHook, PVOID hookproc, BYTE priority );
  10.     VOID    (__stdcall*unhook)( PPHOOKER hHook, PVOID hookproc );
  11.     VOID    (__stdcall*unhookall)( PPHOOKER hHook );
  12.     BOOL    (__cdecl *Call_Hookproc)( PPHOOKER hHook, ... );
  13.     BOOL    (__stdcall*Call_Hookproc0)( PPHOOKER hHook );
  14.     VOID    (__cdecl *Broadcast_Hookproc)( PPHOOKER hHook, ... );
  15.     VOID    (__stdcall*Broadcast_Hookproc0)( PPHOOKER hHook );
  16.  
  17. //---------------------------------------------
  18.     // String
  19.     int        (__stdcall*strlen)(char *str);
  20.     int        (__stdcall*stricmp)(PSTR dst,PSTR src);
  21.     PSTR    (__stdcall*strcat)( PSTR p1,PSTR p2);
  22.     PSTR    (__stdcall*strcpy)( PSTR p1,PSTR p2);
  23.     int        (__stdcall*memcmp)( PVOID buf1, PVOID buf2, size_t count );
  24.     int        (__stdcall*strcmp)( PSTR p1,PSTR p2);
  25.     PSTR    (__stdcall*strchr)( PSTR p1,CHAR c);
  26.     PSTR    (__stdcall*strrchr)( PSTR p1,CHAR c);
  27.     PSTR    (__stdcall*strstr)( PSTR p1,PSTR p2);
  28.     PVOID    (__stdcall*memset)    ( PVOID p1,char c,size_t i);
  29.     PVOID    (__stdcall*memcpy)( PVOID p1,PVOID p2,size_t n);
  30.     BOOL    (__stdcall*strcmp_wild)(PSTR s,PSTR wild); // return FALSE if string coin
  31.     int        (__stdcall*memicmp)(PVOID first,PVOID last,size_t count);
  32.     PSTR    (__stdcall*strncpy)(PSTR p1,PSTR p2,size_t n);
  33.     PSTR    (__stdcall*strupr)( PSTR p1 );
  34.     PSTR    (__stdcall*new_STRING)(PSTR p);    
  35.     
  36.     DWORD    (__cdecl *vsprintf)( PSTR Buf, PSTR Format, va_list ap );
  37.     DWORD    (__cdecl *sprintf)( PSTR Buf, PSTR Format, ... );
  38.  
  39. //---------------------------------------------
  40.     // Momory
  41.     void*    (_stdcall*malloc)(size_t s);
  42.     void    (_stdcall*free)(void* p);
  43.     void*    (_stdcall*realloc)(void* p,size_t s);
  44.  
  45. //---------------------------------------------
  46.     // Symbol
  47.     PPHOOKER    hh_get_module_area;
  48.     //  BOOL hookproc(ADDRE addr, PSTR* area ),
  49.  
  50.     PPHOOKER    hh_symbol_to_address;    
  51.     //  BOOL hookproc(PSTR Sym, ADDRE *paddr)
  52.  
  53.     PPHOOKER    hh_Addr_to_symbol;
  54.     //    BOOL hookproc(ADDRE addr,PSTR *sym,DWORD *limit)
  55.     //*limit is the input limit, do not set it unlese you find a symbol
  56.     //return TRUE only if you get it exactly, with *limit=0
  57.  
  58.     PSTR    (__stdcall*AddressToSymbol)( IN PADDRE addr );
  59.     PSTR    (__stdcall*GetSymbol)( IN PADDRE addr, DWORD Limit );
  60.     PSTR    (__stdcall*GetSymbolArea)( IN PADDRE addr );
  61.     BOOL    (__stdcall*SymbolToAddress)(IN PSTR buffer,OUT PADDRE paddr );
  62.  
  63. //---------------------------------------------
  64.     // Command
  65.     VOID    (__stdcall*Add_Command)( PSTR command, 
  66.                             PSTR Help_1,
  67.                             PSTR Help_2,
  68.                             PSTR Example, 
  69.                             BOOL(_stdcall* h)(int argc,PSTR* argv) );
  70.     VOID    (__stdcall*Remove_Command)( PSTR command );
  71.  
  72.     DWORD    (__stdcall*Reload_Command)( PSTR cmdstr, 
  73.                             BOOL(_stdcall* h)(int argc,PSTR* argv) );
  74.     BOOL    (__stdcall*Run_Command)( PSTR buffer );
  75.     VOID    (__stdcall*Get_Command_Help)( PSTR InputBuf, PSTR OutputBuf );
  76.     PSTR    (__stdcall*Get_Related_Command)( PSTR InputBuf );
  77.     PSTR    (__stdcall*GetInputcmdLine)();
  78.     
  79. //---------------------------------------------
  80.     // INI file
  81.     BOOL    (__stdcall*ini_STR)        (IN PSTR szKey,OUT PSTR *ret );
  82.     BOOL    (__stdcall*ini_BOOL)    (IN PSTR szKey,OUT BOOL *ret );
  83.     BOOL    (__stdcall*ini_DEC)        (IN PSTR szKey,OUT DWORD *ret );
  84.     BOOL    (__stdcall*ini_DWORD)    (IN PSTR szKey,OUT DWORD *ret );
  85.     void    (__stdcall*ini_ForEach)    (IN PSTR szKey,OUT PVOID func);
  86.  
  87. //---------------------------------------------
  88.     // Ring0 File IO
  89.     HANDLE    (__stdcall*fopen)(PSTR pfilename,DWORD mode);
  90.     VOID    (__stdcall*fclose)(HANDLE h);
  91.     DWORD    (__stdcall*fseek)(HANDLE h,DWORD pos);
  92.     DWORD    (__stdcall*fwrite)(HANDLE h,PVOID buffer,DWORD Count);
  93.     DWORD    (__stdcall*fread)(HANDLE h,PVOID buffer,DWORD Count);
  94.     BOOL    (__stdcall*fgets)(HANDLE h,OUT PSTR s);
  95.     DWORD    (__stdcall*fputs)(HANDLE h,IN PSTR s);
  96.  
  97. //---------------------------------------------
  98.     // Memory&Selector
  99.     BOOL    (__stdcall*Set_Page_Map)(DWORD Linear,DWORD Map);
  100.     BOOL    (__stdcall*Get_Page_Map)(DWORD Linear,DWORD* Map);
  101.     BOOL    (__stdcall*LinearToPhys)(DWORD Linear,DWORD* Phys);
  102.     BOOL    (__stdcall*PhysToLinear)(DWORD Phys ,DWORD* Linear);
  103.  
  104.     BOOL    (__stdcall*ifReadable_flat)(DWORD Linear);
  105.     BOOL    (__stdcall*ifReadable)(PADDRE addr);
  106.     BOOL    (__stdcall*ToFlat)(PADDRE addr,DWORD* Linear);
  107.     
  108.     BOOL    (__stdcall*CompareSel)( WORD seg1, WORD seg2 );
  109.     WORD    (__stdcall*ValidSel)( WORD seg );
  110.     // return the valid selector
  111.     BOOL    (__stdcall*Sel16_32)( WORD sel );
  112.     //0:invalid 1:16bit 2:32bit
  113.     BOOL    (__stdcall*Sel_Ring0_3)( WORD sel );
  114.     //0:invalid 1:Ring0 2:Ring3
  115.  
  116.     BOOL    (__stdcall*ValidAddr)(PADDRE ptgt,PADDRE psrc);
  117.  
  118.     void    (__stdcall*toR0CS)(DWORD linear,PADDRE paddr);
  119.     void    (__stdcall*toR0DS)(DWORD linear,PADDRE paddr);
  120.     void    (__stdcall*toR3CS)(DWORD linear,PADDRE paddr);
  121.     void    (__stdcall*toR3DS)(DWORD linear,PADDRE paddr);
  122.     BOOL    (__stdcall*ifR0CS)( PADDRE addr );
  123.     BOOL    (__stdcall*ifR0DS)( PADDRE addr );
  124.     BOOL    (__stdcall*ifR3CS)( PADDRE addr );
  125.     BOOL    (__stdcall*ifR3DS)( PADDRE addr );
  126.  
  127.     BOOL    (__stdcall*ifLinear)(PADDRE paddr);
  128.     VOID    (__stdcall*CurCSEIP)(PADDRE paddr);
  129.  
  130.     BOOL    (__stdcall*PeekB)(PADDRE paddr,OUT BYTE* b);
  131.     BOOL    (__stdcall*PeekW)(PADDRE paddr,OUT WORD* w);
  132.     BOOL    (__stdcall*PeekD)(PADDRE paddr,OUT DWORD* dw);
  133.  
  134. //---------------------------------------------
  135.     // Hex&Dec&String
  136.     PSTR    (__stdcall*str2dec)(PSTR s,OUT DWORD* d);
  137.     PSTR    (__stdcall*str2hex)(PSTR s,OUT DWORD* d);
  138.     VOID    (__stdcall*dec2str)(DWORD d,OUT PSTR s);
  139.     VOID    (__stdcall*hex2str)(DWORD d,OUT PSTR s);
  140.  
  141. //---------------------------------------------
  142.     // Kernel
  143.     PPHOOKER hh_IntObj;
  144.     // CallBack proc prohotype
  145.     // BOOL STDCALL hookproc(DWORD IntNum) 
  146.  
  147.     PPHOOKER hh_PreEnterKernel;
  148.     // CallBack proc prohotype
  149.     // BOOL STDCALL hookproc() 
  150.     // return TRUE will not enter kernel, v.v.
  151.  
  152.     PPHOOKER hh_EnterKernel;
  153.     // CallBack proc prohotype
  154.     // VOID STDCALL hookproc() 
  155.  
  156.     PPHOOKER hh_OnMessageLoop;
  157.     // CallBack proc prohotype
  158.     // BOOL STDCALL hookproc() 
  159.  
  160.     PPHOOKER hh_LeaveKernel;
  161.     // CallBack proc prohotype
  162.     // VOID STDCALL hookproc() 
  163.  
  164.     PPHOOKER hh_PostLeaveKernel;
  165.     // CallBack proc prohotype
  166.     // VOID STDCALL hookproc() 
  167.  
  168.     BYTE*    pfV86;
  169.     BYTE*    pfPM;
  170.     BYTE*    pfVMM;
  171.     BYTE*    pfUserVM;
  172.  
  173.     CLIENT_STRUCT*    pUser;
  174.     X86_REG_STRUCT*    pUserX86;
  175.  
  176.     DWORD*    pWindows_IntNum;
  177.  
  178.     DWORD*    pCur_Thread_Handle;
  179.     DWORD*    pCur_VM_Handle;
  180.     DWORD*    pCur_Process_DB;
  181.  
  182.     VOID    (__stdcall*Ring3_CallBack)(PVOID Ring3_callback,PVOID Ring0_callback);
  183.  
  184.     VOID    (__stdcall*Set_Enter_Kernel)();
  185.     VOID    (__stdcall*Set_Leave_Kernel)();
  186.  
  187.     VOID    (__stdcall*UpdateIDT)( );
  188.  
  189.     BYTE    (__stdcall*Read_Port)( DWORD Port );
  190.     VOID    (__stdcall*Write_Port)( DWORD Port, BYTE wData );
  191.     
  192.     BOOL    (__stdcall*GetExpression)(IN PSTR expr,OUT DWORD* result);
  193.  
  194.     VOID    (__stdcall*FatalError)(IN PSTR msg);
  195.  
  196.     VOID    (__stdcall*Begin_Nest_VMM_Exec)();
  197.     VOID    (__stdcall*End_Nest_VMM_Exec)();
  198.  
  199.     BOOL*    pfSoft_1Step;
  200.     BOOL    (__stdcall*GetTraceFlag)();
  201.     VOID    (__stdcall*Get_Origin_Interrupt_Vector)( DWORD  IntNum,
  202.                                            DWORD* IntSeg,
  203.                                            DWORD* IntOff,
  204.                                            BOOL*  GateSize);
  205.  
  206. //---------------------------------------------
  207.     // Driver
  208.     // Timer
  209.     DWORD    (__stdcall*Get_Time)();
  210.  
  211.     // Keyboard
  212.     PPHOOKER hh_HotKey;
  213.     // Hookprpoc:
  214.     // BOOL STDCALL hookproc( DWORD keycode );     
  215.  
  216.     WORD    (__stdcall*Get_Key)( );
  217.     VOID    (__stdcall*Clear_Key_Buf)( );
  218.     BYTE    (__stdcall*Get_CTRL_Key)( );
  219.     WORD    (__stdcall*Wait_Key)( );
  220.     VOID    (__stdcall*Set_Ring0_Hotkey)(WORD key);
  221.     VOID    (__stdcall*Set_Ring3_Hotkey)(WORD key);
  222.  
  223.     BYTE    (__stdcall*Get_Keyboard_State)();
  224.     void    (__stdcall*Set_Keyboard_State)(BYTE f);
  225.  
  226.     // Display
  227.     PPHOOKER hh_DisplaySetMode;
  228.     // CallBack proc prohotype
  229.     // BOOL STDCALL hookproc() 
  230.  
  231.     PPHOOKER hh_DisplaySaveRegister;
  232.     // CallBack proc prohotype
  233.     // BOOL STDCALL hookproc() 
  234.  
  235.     PPHOOKER hh_DisplayRestoreRegister;
  236.     // CallBack proc prohotype
  237.     // BOOL STDcALL hookproc() 
  238.  
  239.     PPHOOKER hh_Notify_Screen_Lines_Change;
  240.     // Add/Remove change screen lines callback .
  241.     // CallBack proc prohotype:
  242.     // VOID STDCALL CallBack( DWORD Lines );
  243.  
  244.     VOID    (__stdcall*TRW2000_Screen)();
  245.     VOID    (__stdcall*User_Screen)();
  246.     VOID    (__stdcall*Set_Cursor)(BYTE x,BYTE y);
  247.     VOID    (__stdcall*Change_Cursor)(BYTE Begin,BYTE End);
  248.     DWORD    (__stdcall*Save_Hardware_Cursor_State)(void);
  249.     VOID    (__stdcall*Restore_Cursor_State)(DWORD State);
  250.  
  251.     // Mouse
  252.     VOID    (__stdcall*Get_Mouse_State)(MOUSE_STATE *State);
  253.     VOID    (__stdcall*Mouse_Show)( );
  254.     VOID    (__stdcall*Mouse_Hide)( );
  255.  
  256. //---------------------------------------------
  257.     // Module16&Module32&VxD
  258.     WORD    (__stdcall*GetMod16Handle)(IN PSTR modname);
  259.     BOOL    (__stdcall*GetMod16Info)(PADDRE paddr,PSTR modname,DWORD* segnum,DWORD* off);
  260.     BOOL    (__stdcall*GetMod16Info2)(PSTR modname,DWORD segnum,PADDRE paddr,DWORD* size);
  261.     DWORD    (__stdcall*GetProc16Address)(PSTR modname,PSTR expname);
  262.  
  263.     DWORD    (__stdcall*GetMod32Handle)(PSTR modname);
  264.     BOOL    (__stdcall*GetMod32Info)(PADDRE paddr,PSTR modname,DWORD* segnum,DWORD* off);
  265.     BOOL    (__stdcall*GetMod32Info2)(PSTR modname,DWORD segnum,PADDRE paddr,DWORD* size);
  266.     DWORD    (__stdcall*GetProc32Address)(PSTR modname,PSTR expname);
  267.  
  268.     BOOL    (__stdcall*GetVxDInfo)(PADDRE paddr,PSTR modname,DWORD* segnum,DWORD* off);
  269.     BOOL    (__stdcall*GetVxDInfo2)(PSTR modname,DWORD segnum,PADDRE paddr,DWORD* size);
  270.  
  271. //---------------------------------------------
  272.     // Disassembler
  273.     PPHOOKER hh_PreUnasm;
  274.     // PSTR hookproc(PADDRE addr,BYTE* usercolor);
  275.     PPHOOKER hh_PostUnasm;
  276.     // PSTR hookproc(PADDRE addr,BYTE* usercolor);
  277.     PPHOOKER hh_user_disasm;
  278.     // Hookprpoc:
  279.     // BOOL STDCALL hookproc( PADDRE addr, DWORD* Len, PSTR UasmBuf );     
  280.  
  281.     BOOL    (__stdcall*Is_P_Inst)(IN PADDRE addre);
  282.     BOOL    (__stdcall*Is_RET_Inst)(IN PADDRE addre);
  283.  
  284.     VOID    (__stdcall*SetDisasmMode)(BOOL f);
  285.     BOOL    (__stdcall*Get_Instruction_Length)(PADDRE paddr,DWORD *Len);
  286.     // The function return FALSE if the address is a non-page status !
  287.     // And, len is set to 1 when address is non-page, or len is
  288.     // the length of specified instruction and return TRUE .
  289.     DWORD    (__stdcall*Disassembler)(PADDRE paddr,PSTR dasmbuf);
  290.     struct PLUG_CPU_INFO* (__stdcall*Get_Instruction_Info)(PADDRE paddr);    
  291.     
  292. //---------------------------------------------
  293.     // Extended Symbol Format
  294.     PPHOOKER hh_InitSymMod;
  295.     PPHOOKER hh_RelocSymMod;
  296.  
  297.     DWORD    (__stdcall*Sym_CreateSymTable)(PSTR modname);
  298.     DWORD    (__stdcall*Sym_LocateSymTable)(PSTR modname);
  299.     VOID    (__stdcall*Sym_DeleteSymTable)(PSTR modname);
  300.     DWORD    (__stdcall*Sym_GetCurSymTable)( );
  301.     VOID    (__stdcall*Sym_SetCurSymTable)( DWORD hSymTable );
  302.     VOID    (__stdcall*Sym_SelectSymTable)(PSTR modname);
  303.     VOID    (__stdcall*Sym_SetSymTableFlag)(DWORD flag);
  304.     DWORD    (__stdcall*Sym_CreateSegment)(DWORD hSymTable,PSTR segname,DWORD segnumber);
  305.     VOID    (__stdcall*Sym_RelocSegment)(DWORD segnumber,PADDRE paddr,DWORD size);
  306.     VOID    (__stdcall*Sym_RelocSegment2)(PSTR segname,PADDRE paddr,DWORD size);
  307.     VOID    (__stdcall*Sym_CreateSymbol)(DWORD segnum,PSTR name,DWORD off,DWORD type);
  308.     VOID    (__stdcall*Sym_DeleteSymbol)(DWORD segnum,DWORD off,DWORD type);
  309.     PSTR    (__stdcall*Sym_Addr2Symbol)( PADDRE addr,DWORD* index,DWORD* offset,DWORD* type );
  310.     PSTR    (__stdcall*Sym_GetNextSym)( DWORD* index,DWORD* type );
  311.     BOOL    (__stdcall*Sym_Symbol2Addr2)(PSTR sym,PADDRE addr,DWORD* type,DWORD* index);
  312.  
  313.     DWORD    (__stdcall*Sym_LoadSrcFileToSymSeg)( DWORD hSegment,PSTR szfilepath );
  314.     PSTR    (__stdcall*Sym_GetCurSrcFileName)();
  315.     DWORD    (__stdcall*Sym_GetCurSrcTotalLines)();
  316.     DWORD    (__stdcall*Sym_GetPrevLine)(DWORD line);
  317.     BOOL    (__stdcall*Sym_Line2Addr)( DWORD line,PADDRE paddr );
  318.     BOOL    (__stdcall*Sym_Addr2Line)( PADDRE paddr,DWORD* begin,DWORD* end);
  319.     BOOL    (__stdcall*Sym_GetSrcFileLine)( DWORD linenum );
  320.     BOOL    (__stdcall*Sym_SetCurSrcFile)( PSTR filename );
  321.     BOOL    (__stdcall*Sym_SetCurSrcFile2)( DWORD hSrc );
  322.     BOOL    (__stdcall*Sym_UpdateSrcFile)( PADDRE paddr , DWORD* lines);
  323.     VOID    (__stdcall*Sym_CreateLineInfo)( DWORD linenum,DWORD lineoff );
  324.     VOID    (__stdcall*Sym_DeleteLineInfo)( DWORD linenum );
  325.     // define in EXTSYM.CPP
  326.  
  327.     DWORD    (__stdcall*Sym_TypeDefine)(PSTR name,DWORD type,DWORD size,DWORD local);
  328.     VOID    (__stdcall*Sym_CreateTypeField)(DWORD owner,DWORD off,DWORD type,PSTR name);
  329.     VOID    (__stdcall*Sym_TypeUndefine)(DWORD type);
  330.  
  331.     PPHOOKER hh_SymComplexSym;
  332.  
  333. //---------------------------------------------
  334.     // User Interface
  335.     DWORD    (__stdcall*Get_CPU_Win_Handle)( );
  336.     DWORD    (__stdcall*Get_Register_Win_Handle)( );
  337.     DWORD    (__stdcall*Get_Data_Win_Handle)( );
  338.     DWORD    (__stdcall*Get_Disassembler_Win_Handle)( );
  339.  
  340.  
  341.     DWORD    (__stdcall*CreateWindow)( DWORD x1,DWORD y1,DWORD x2,DWORD y2,
  342.                          PSTR title, DWORD Style,
  343.                          int delta_x, int delta_y, int off_x, int off_y,
  344.                          PVOID Handler,
  345.                          int min_x, int min_y, int max_x, int max_y);
  346.     // Cteate a Window and show it on the screen .
  347.     // x1, y1, x2, y2 specify the coordinates of screen .
  348.     // delta_x, delta_y specify the offset value .
  349.     // off_x, off_y specify the max value of offset .
  350.     // Draw routine is the proc of Scroller,
  351.     // Hadnler routine is the proc of Scroller,
  352.     // Refurbish routine is the proc of Scroller .
  353.     // Return the handle of Window .
  354.     // Style can use the values specified below :
  355.     //
  356.     //       STDDASM :   A standard Disassembler Window .
  357.     //                   delta_x,delta_y, off_x, off_y will be ignored .
  358.     //
  359.     //       STDDATA :   A standard wData Window .
  360.     //                   delta_x,delta_y, off_x, off_y will be ignored .
  361.     //
  362.     //       STDUSER :   A user-specified Window .
  363.     //
  364.     //       These values can't be ORed .
  365.     //
  366.     //       SY_MOVE :   Window can be moved .
  367.     //
  368.     //       SY_ZOOM :   Window can be zoomed .
  369.     //
  370.     //       SY_SIZE :   Window can be resized .
  371.     //
  372.     //       SY_CLOSE:   Window can be closed .
  373.     //
  374.     //       SY_TOP:     Window is always on the top of screen .
  375.     //
  376.     //       These values can be ORed .
  377.  
  378.     VOID    (__stdcall*DesktopReDraw)( );
  379.  
  380.     DWORD    (__stdcall*FindWindow)( WORD msg );
  381.     VOID    (__stdcall*FocusWindow)( DWORD view );
  382.     VOID    (__stdcall*SendMessage)( DWORD view, WORD msg );
  383.     VOID    (__stdcall*ClearEvent)( DWORD, TEvent& );
  384.     VOID    (__stdcall*SetWindowColor)( DWORD view,BYTE color);
  385.     BYTE    (__stdcall*GetWindowColor)( DWORD view);
  386.  
  387.     void    (__stdcall*SetPageShowTitle)(PSTR Title);
  388.     void    (__stdcall*BeginPageShow)();
  389.     void    (__stdcall*EndPageShow)();
  390.  
  391.     VOID    (__stdcall*WindowPutc)( DWORD view,int x,int y,char c);
  392.     DWORD    (__cdecl *WindowPrintf)( DWORD view, int x, int y, PSTR Format, ... );
  393.  
  394.     VOID    (__stdcall*GetWindowHandle)( DWORD client );
  395.     VOID    (__stdcall*DeleteWindow)( DWORD view );
  396.  
  397.     VOID    (__stdcall*DisableCommandWindow)( );
  398.     VOID    (__stdcall*EnableCommandWindow)( );
  399.     DWORD    (__stdcall*puts)(PSTR buffer);
  400.     VOID    (__stdcall*putc)(char c);
  401.     DWORD    (__cdecl *dprintf)( PSTR Format, ... );
  402.  
  403.     WORD    (__stdcall*MessageBox)(PSTR title,PSTR message);
  404.     WORD    (__stdcall*InputBox)(PSTR title,PSTR message,PSTR buf,WORD MaxLen);
  405.  
  406.     // That you see :
  407.     //
  408.     //   STDDASM WinProc prototype :
  409.     //           WinProc( TView* view, TEvent& event, DASM_WNDCLASS& wnd );
  410.     //
  411.     //   STDDATA WinProc prototype :
  412.     //           WinProc( TView* view, TEvent& event, DATA_WNDCLASS& wnd );
  413.     //
  414.     //   STDUSER WinProc prototype :
  415.     //           WinProc( TView* view, TEvent& event, WNDCLASS& wnd );
  416.  
  417.     VOID    (__stdcall*GetWNDClass)( DWORD view, WNDCLASS& wnd );
  418.     VOID    (__stdcall*SetWNDClass)( DWORD view, WNDCLASS& wnd );
  419.     VOID    (__stdcall*GetDASM_WNDClass)( DWORD view, DASM_WNDCLASS& wnd );
  420.     VOID    (__stdcall*SetDASM_WNDClass)( DWORD view, DASM_WNDCLASS& wnd );
  421.     VOID    (__stdcall*GetDATA_WNDClass)( DWORD view, DATA_WNDCLASS& wnd );
  422.     VOID    (__stdcall*SetDATA_WNDClass)( DWORD view, DATA_WNDCLASS& wnd );
  423.  
  424. //---------------------------------------------
  425.     // P CheckProc
  426.     VOID    (__stdcall*AddPCheck)( PVOID theCheckProc );
  427.     VOID    (__stdcall*DelPCheck)( PVOID theCheckProc );
  428.     VOID    (__stdcall*BeginPRun)();
  429.     VOID    (__stdcall*BeginTRun)();    
  430.  
  431. //---------------------------------------------
  432.     // Breakpoint
  433.     WORD*    pActive_BP_ID;
  434.  
  435.     BYTE    (__stdcall*addBPInt3)( PADDRE paddr,DWORD mode );
  436.     BYTE    (__stdcall*addBPDr)( PADDRE paddr,DWORD mode,DWORD type,DWORD size );
  437.     BOOL    (__stdcall*AddressIfBP)( PADDRE addr );
  438.     VOID    (__stdcall*EnableBP)(BYTE id);
  439.     VOID    (__stdcall*DisableBP)(BYTE id);
  440.  
  441.     VOID    (__stdcall*Set_BP_Active)(BYTE id);
  442.     VOID    (__stdcall*Set_BP_Unactive)(BYTE id);
  443.     VOID    (__stdcall*DeleteBP)(BYTE id);
  444.     VOID    (__stdcall*addCheckProc)(BYTE id,PVOID checkproc);
  445.     VOID    (__stdcall*SetIfThenDo)(BYTE id,int argc,PSTR* argv); 
  446.     struct tagMYBP*    (__stdcall*LocateBP)(BYTE id);
  447.     VOID    (__stdcall*RecordBPCmdLine)(BYTE id,PSTR InputCmdLine);
  448. /*
  449.     Please, DO NOT develop any breakpoint plug-ins now! Because we are
  450.     developing breakpoint-system now, all interface of breakpoint-system 
  451.     maybe changed!
  452. */    
  453.  
  454. //---------------------------------------------
  455.     // Version 1.13 Added
  456.     // Mod16&Mod32
  457.     WORD    (*GetFirstTask)();
  458.     DWORD    (*GetMTElist)();
  459.     DWORD    (*GetCurrentPDB)();
  460.  
  461.     PPHOOKER hh_OnRing3Message;
  462.     VOID    (*PostMessageToDll)(DWORD wParam,DWORD lParam);
  463.  
  464. //---------------------------------------------
  465.     // Version 1.15 Added
  466.     BOOL    (*getNum)(PSTR buf,DWORD* num);
  467.     // Video Display
  468.     // BOOL hookproc(DWORD I_code,DWORD param1,DWORD param2);
  469.  
  470.     // I_code define
  471.     // #define DD_ENTERDEBUGGER    1    
  472.     // No param. It notify plug-ins that TRW2000 need to show debugger 
  473.     // screen and be actived soon.
  474.     
  475.     // #define DD_LEAVEDEBUGGER    2
  476.     // No Param. It notify plug-ins that TRW2000 will exit and need to 
  477.     // restore Windows screen.
  478.     // NOTE: If user press F4(RS) to see Windows screen, TRW2000 will
  479.     //         call DD_LEAVEDEBUGGER at first, then wait for a key, at 
  480.     //         last TRW2000 call DD_ENTERDEBUGGER.
  481.  
  482.     // #define DD_REDRAWSCREEN    3    //Param1: ScreenBuf(8192 byets), Param2: Lines
  483.     // It notify plug-ins that TRW2000 will redraw screen. Param1 point 
  484.     // to screen buffer, the size of screen buffer is 8192bytes.(80*50*2=8000)
  485.     // Param2 is current lines(high word is width value, now fixed, is 80)
  486.     // The range of lines is from 25 to 50.
  487.     // If plug-ins did not support current lines, e.g: CGA not support 50 lines.
  488.     // Plug-ins should call API Set_Display_Screen_Lines to change screen lines. 
  489.     
  490.     // #define DD_MOUSECURSHOW    4    //Param1: X, Param2: Y
  491.     // It notify that mouse driver would show mouse cursor.
  492.     // Mouse cursor is a software cursor, plug-ins must save the character at
  493.     // the position of mouse cursor first. Then show the cursor.
  494.     
  495.     // #define DD_MOUSECURHIDE    5    //Param1: X, Param2: Y
  496.     // It notify that mouse driver would hide mouse cursor.
  497.     // At this time plug-ins should restore the character that saved at
  498.     // DD_MOUSECURSHOW.
  499.  
  500.     // #define DD_CURSORCHANGE    6    //Param1: BeginLine, Param2: EndLine
  501.     // Notify that TRW2000 want to change cursor. 
  502.     
  503.     // #define DD_CURSORPOS        7    //Param1: X, Param2: Y
  504.     // Notify that TRW2000 want to change cursor position.
  505.  
  506.     // #define DD_CURSORSAVE    8    //Param1: Pointer to state (DWORD)
  507.     // #define DD_CURSORRESTORE    9    //Param1: State(DWORD)
  508.  
  509.     // Sure, plug-ins must handle DD_ENTERDEBUGGER, DD_LEAVEDEBUGGER,
  510.     // DD_REDRAWSCREEN, DD_MOUSECURSHOW, DD_MOUSECURHIDE, DD_CURSORCHANGE,
  511.     // DD_CURSORPOS. 
  512.  
  513.     PPHOOKER hh_DisplayRedrawProc;
  514.     // designed for second MONO display device
  515.     VOID    (*Set_Display_Screen_Lines)( DWORD Line );
  516.  
  517. } PLUGS_API;
  518.  
  519.